package experimentOne;

import java.util.Random;

class RoundRobin {
    static int quantum; //定义时间片

    // 计算每个进程的等待时间的方法
    static void findWaitingTime(Process[] proc, int n, int[] wt){
        int[] rem_bt = new int[n]; // 保存每个进程还剩下的时间
        // 将每个进程的运行时间赋值给剩余时间
        for (int i = 0 ; i < n ; i++) {
            rem_bt[i] =  proc[i].burstTime;
        }
        int t = 0; // 记录当前时刻
        // 当所有进程的剩余时间都为0时，结束循环
        while(true){
            boolean done = true;
            // 遍历所有进程
            for (int i = 0 ; i < n; i++){
                // 进程还有剩余的运行时间
                if (rem_bt[i] > 0){
                    done = false;
                    // 如果剩余时间更大
                    if (rem_bt[i] > quantum){
                        // 用掉一个时间片
                        t += quantum;
                        // 剩余时间减一个时间片
                        rem_bt[i] -= quantum;
                    }
                    else{
                        // 如果剩余时间更小，那么直接用掉剩余时间
                        t = t + rem_bt[i];
                        // 计算等待时间
                        wt[i] = t - proc[i].burstTime;
                        // 把剩余时间设为0
                        rem_bt[i] = 0;
                    }
                }
            }
            // 如果所有进程的剩余时间都是0，结束循环
            if (done)
                break;
        }
    }

    // 计算每个进程的周转时间（完成时间-到达时间）的方法
    static void findTurnAroundTime(Process[] proc, int n, int[] wt, int[] tat){
        for (int i = 0; i < n ; i++)
            tat[i] = proc[i].burstTime + wt[i];
    }

    public static void main(String[] args){
        int processCount = 5; // 你需要的进程数
        Process[] proc = new Process[processCount];
        Random random = new Random();

        for(int i=0; i < processCount; i++) {
            proc[i] = new Process();
            proc[i].processName = "P" + (i+1);
            proc[i].arrivalTime = 0; // 到达时间，可根据需要调整

            // 设定burstTime（运行时间）为两倍的进程索引，也可以根据你的需求进行修改
            proc[i].burstTime = random.nextInt(20);
        }

        quantum = 2; // 定义时间片
        int[] wt = new int[processCount], tat = new int[processCount];
        findWaitingTime(proc, processCount, wt); // 计算等待时间
        findTurnAroundTime(proc, processCount, wt, tat); // 计算每个进程的周转时间

        // 输出结果
        System.out.println(" 进程名" +
                "\t" +"运行时间" +"\t "+
                "等待时间" +"\t " + "周转时间");
        int total_wt = 0, total_tat = 0;
        for (int i=0; i<processCount; i++){
            total_wt = total_wt + wt[i];
            total_tat = total_tat + tat[i];
            System.out.println(" "+ proc[i].processName +
                    "\t\t" + proc[i].burstTime +"\t\t "+
                    wt[i] +"\t\t\t " + tat[i]);
        }
        // 计算平均等待时间和平均周转时间
        System.out.println("平均等待时间 = "+ (float)total_wt / (float)processCount);
        System.out.println("平均周转时间 = "+ (float)total_tat / (float)processCount);
    }

}